/*
 * Copyright (c) 2010-2011 NOO. All Rights Reserved.
 * [Id:BaseBean.java  11-10-24 上午12:35 poplar.yfyang ]
 */
package org.mumu.pawn.fm;

import com.google.common.collect.Maps;
import org.apache.commons.lang.StringUtils;
import org.mumu.pawn.fm.dm.LazyPawnDataModel;
import org.mumu.pawn.fm.util.OrderField;
import org.mumu.pawn.fm.util.QueryField;
import org.mumu.pawn.fm.util.SortUtils;
import org.richfaces.component.SortOrder;

import javax.annotation.PostConstruct;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 基础受管Bean.
 * </p>.
 *
 * @author poplar.yfyang
 * @version 1.0 11-10-24 上午12:35
 * @since JDK 1.5
 */
public abstract class BaseBean<T> implements Serializable {

    private static final long serialVersionUID = -7353008833041887828L;
    /**
     * 实体
     */
    private T entity;

    /**
     * 实体数据模型
     */
    private LazyPawnDataModel<T> lazyDataModelLazy;

    /**
     * 排序字段，以实体属性为准
     */
    private Map<String, SortOrder> sortOrders = Maps.newHashMapWithExpectedSize(1);
    /**
     * 查询过滤字段
     */
    private Map<String, String> filterValues = Maps.newHashMap();
    /**
     * 当前排序要求
     */
    private String sortProperty;


    /**
     * 构造器
     */
    @PostConstruct
    protected void init() {
        setEntity(createNewEntity());
        lazyDataModelLazy = builderDataModel();
        //构建排序
        List<OrderField> sortFileds = SortUtils.getFilterColumn(getEntityClass());
        for (OrderField sortFiled : sortFileds) {
            sortOrders.put(sortFiled.getFieldName(), sortFiled.getOrder());
        }
        //自定义过滤
        setFilters();
    }

    /**
     * 打开增加面板
     */
    public void popupAdd() {
        this.entity = createNewEntity();
    }


    public void save() {
        //刷新分页
        this.lazyDataModelLazy.cleanRowCount();
        doSave();
    }

    public void remove() {
        //刷新分页
        this.lazyDataModelLazy.cleanRowCount();
        doRemove();
    }

    /**
     * 创建一个新的实体实例
     *
     * @return 实体实例
     */
    protected T createNewEntity() {
        try {
            return getEntityClass().newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 创建一个数据提供者，使用数据库分页延迟。
     *
     * @return 数据提供模型
     */
    protected abstract LazyPawnDataModel<T> builderDataModel();

    /**
     * 执行删除操作
     */
    protected abstract void doRemove();

    /**
     * 执行保存操作
     */
    protected abstract void doSave();

    /**
     * 设置自定义查询,如果不需要进行自定义过滤查询，则返回null即可
     *
     * @return 自定义过滤信息
     */
    protected abstract List<QueryField> initQueryFields();

    /**
     * 设置自定义过滤，相当于自定义查询，针对数据模型
     */
    protected void setFilters() {
        List<QueryField> fields = initQueryFields();
        if (fields == null) {
            return;
        }
        this.lazyDataModelLazy.setCustomerQueryField(fields);
    }


    public LazyPawnDataModel<T> getLazyDataModelLazy() {
        return lazyDataModelLazy;
    }

    /**
     * 取得排序字段信息
     *
     * @return 排序字段
     */
    public Map<String, SortOrder> getSortOrders() {
        return sortOrders;
    }

    /**
     * 取得过滤字段信息
     *
     * @return 过滤字段信息
     */
    public Map<String, String> getFilterValues() {
        return filterValues;
    }

    /**
     * 获取当前排序字段
     *
     * @return 当前排序字段
     */
    public String getSortProperty() {
        return sortProperty;
    }

    /**
     * 设置当前排序字段
     *
     * @param sortPropety 当前排序字段属性
     */
    public void setSortProperty(String sortPropety) {
        this.sortProperty = sortPropety;
    }

    /**
     * 设置排序信息
     */
    public void toggleSort() {
        SortOrder newOrder;
        for (Map.Entry<String, SortOrder> entry : sortOrders.entrySet()) {
            newOrder =
                    StringUtils.equals(entry.getKey(), sortProperty) ?
                            (entry.getValue() == SortOrder.ascending ?
                                    SortOrder.descending :
                                    SortOrder.ascending) :
                            SortOrder.unsorted;

            entry.setValue(newOrder);
        }
    }

    public T getEntity() {
        return entity;
    }

    public void setEntity(T entity) {
        this.entity = entity;
    }


    /**
     * 获取当前实体的Class类型。
     *
     * @return Class类型
     */
    private Class<T> getEntityClass() {
        return (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }
}
